{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dqb0-ZEk4UBg",
        "outputId": "dd3b8d73-4c7c-4642-b567-150efef05a32"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R04Us1Az4oUv"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.metrics import r2_score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZY9W9m275Cht",
        "outputId": "0fc0f41e-7bcd-44b4-ab43-9fe14a15f486"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "# Define the device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "print(device)\n",
        "\n",
        "training_data = np.load('/content/gdrive/My Drive/training_n_data.npy')[:2000]\n",
        "training_std = np.load('/content/gdrive/My Drive/training_std.npy')[:2000]\n",
        "\n",
        "testing_data = np.load('/content/gdrive/My Drive/testing_n_data.npy')[:2000]\n",
        "testing_std = np.load('/content/gdrive/My Drive/testing_std.npy')[:2000]\n",
        "\n",
        "# Reshape to 2D Array\n",
        "training_data = training_data.reshape(training_data.shape[0], 3, -1)\n",
        "testing_data = testing_data.reshape(testing_data.shape[0], 3, -1)\n",
        "\n",
        "# Convert to PyTorch tensors\n",
        "training_data_tensor = torch.tensor(training_data, dtype=torch.float32).to(device)\n",
        "training_std_tensor = torch.tensor(training_std, dtype=torch.float32).to(device)\n",
        "testing_data_tensor = torch.tensor(testing_data, dtype=torch.float32).to(device)\n",
        "testing_std_tensor = torch.tensor(testing_std, dtype=torch.float32).to(device)\n",
        "\n",
        "# Create TensorDatasets\n",
        "train_dataset = TensorDataset(training_data_tensor, training_std_tensor)\n",
        "test_dataset = TensorDataset(testing_data_tensor, testing_std_tensor)\n",
        "\n",
        "# Create DataLoaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=20, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=50, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AvLG-F5v5Eq_"
      },
      "outputs": [],
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, input_size):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv1d(3, 82, kernel_size=4, stride=1)\n",
        "        self.fc1 = nn.Linear(82 * (input_size - 3), 512)\n",
        "        self.fc2 = nn.Linear(512, 120)\n",
        "        self.fc3 = nn.Linear(120, 10)\n",
        "        self.fc4 = nn.Linear(10, 1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.conv1(x))\n",
        "        #x = self.pool(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        x = F.relu(self.fc3(x))\n",
        "        x = self.fc4(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3m10sb5I5woT"
      },
      "outputs": [],
      "source": [
        "model = CNN(40)\n",
        "criterion = nn.L1Loss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1lUQ03O65rS1"
      },
      "outputs": [],
      "source": [
        "def run_model(model, train_loader, test_loader, criterion, optimizer, device, epochs=10):\n",
        "    for i in range(epochs):\n",
        "        #(f\"Starting epoch {i + 1} of {epochs}\")\n",
        "        train_loss = 0.0\n",
        "        test_loss = 0.0\n",
        "\n",
        "        model.train()\n",
        "        for b, (X_train, y_train) in enumerate(train_loader):\n",
        "            X_train, y_train = X_train.to(device), y_train.to(device)\n",
        "            y_pred = model(X_train)\n",
        "            target = y_train.view(-1, 1)\n",
        "            target = target.expand_as(y_pred)\n",
        "            loss = criterion(y_pred, target)\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            train_loss += loss.item()\n",
        "\n",
        "        average_train_loss = train_loss / len(train_loader)\n",
        "        #print(f\"Average training loss for epoch {i + 1}: {average_train_loss}\")\n",
        "\n",
        "        model.eval()\n",
        "        with torch.no_grad():\n",
        "            for X_test, y_test in test_loader:\n",
        "                X_test, y_test = X_test.to(device), y_test.to(device)\n",
        "                y_val = model(X_test)\n",
        "                target = y_test.view(-1, 1)\n",
        "                target = target.expand_as(y_val)\n",
        "                loss = criterion(y_val, target)\n",
        "                test_loss += loss.item()\n",
        "\n",
        "        average_test_loss = test_loss / len(test_loader)\n",
        "        if i % (epochs//2) == 0:\n",
        "          print(f\"Epoch {i}/{epochs} | Testing Loss: {average_test_loss} | Training Loss: {average_train_loss} \")\n",
        "\n",
        "    return average_train_loss, average_test_loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2gMFnRvDDxnw"
      },
      "outputs": [],
      "source": [
        "def removal_from_sides(model, train_loader, test_loader, criterion, optimizer, device, epochs=15):\n",
        "    results = []  # list to hold the results\n",
        "\n",
        "    for i in range(train_loader.dataset.tensors[0].size(2), 0, -1):\n",
        "        if i <= 3:\n",
        "          break\n",
        "        else:\n",
        "          for side in ['left', 'right']:\n",
        "              print(f\"Training with {i} features, removing from {side}\")\n",
        "\n",
        "              if side == 'left':\n",
        "                  train_data = train_loader.dataset.tensors[0][:, :, :i].clone()\n",
        "                  test_data = test_loader.dataset.tensors[0][:, :, :i].clone()\n",
        "              else:  # 'right'\n",
        "                  train_data = train_loader.dataset.tensors[0][:, :, -i:].clone()\n",
        "                  test_data = test_loader.dataset.tensors[0][:, :, -i:].clone()\n",
        "\n",
        "              input_size = train_data.size(2)  # Update the input size\n",
        "\n",
        "              model = CNN(input_size)  # Update the model initialization\n",
        "              model.to(device)\n",
        "              optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
        "\n",
        "              train_loader_ablated = torch.utils.data.DataLoader(\n",
        "                  torch.utils.data.TensorDataset(train_data, train_loader.dataset.tensors[1]),\n",
        "                  batch_size=train_loader.batch_size,\n",
        "                  shuffle=True\n",
        "              )\n",
        "\n",
        "              test_loader_ablated = torch.utils.data.DataLoader(\n",
        "                  torch.utils.data.TensorDataset(test_data, test_loader.dataset.tensors[1]),\n",
        "                  batch_size=test_loader.batch_size,\n",
        "              )\n",
        "\n",
        "              average_train_loss, average_test_loss = run_model(\n",
        "                  model, train_loader_ablated, test_loader_ablated, criterion, optimizer, device, epochs\n",
        "              )\n",
        "\n",
        "              results.append((i, side, average_train_loss, average_test_loss))\n",
        "\n",
        "    return results\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4FOa0_B_7-CS"
      },
      "outputs": [],
      "source": [
        "results = removal_from_sides(model, train_loader, test_loader, criterion, optimizer, device, epochs=100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QUfNDmqs77ea"
      },
      "outputs": [],
      "source": [
        "def plot_results(results):\n",
        "    num_features = [r[0] for r in results]\n",
        "    sides = [r[1] for r in results]\n",
        "    MAE = [r[3] for r in results]\n",
        "\n",
        "    fig, ax = plt.subplots(figsize=(10,4))\n",
        "    plt.xticks(fontsize=20)\n",
        "    plt.yticks(fontsize=20)\n",
        "\n",
        "    ax.scatter(num_features[::2], MAE[::2], label='From Left')\n",
        "    ax.scatter(num_features[1::2], MAE[1::2], label='From Right')\n",
        "    ax.set_xlabel('Number of Features Per Channel')\n",
        "    ax.set_ylabel('MAE')\n",
        "    ax.legend(fontsize=15)\n",
        "    ax.set_ylim(0, 0.255)\n",
        "    ax.invert_xaxis()\n",
        "    plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 407
        },
        "id": "a3_gcO9u7_hf",
        "outputId": "bc85c531-8acf-45ad-b864-d5fe3bda428a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plot_results(results)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yGjebcDY3qpX"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}